{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package stopwords to\n",
      "[nltk_data]     /Users/Jialin/nltk_data...\n",
      "[nltk_data]   Package stopwords is already up-to-date!\n",
      "[nltk_data] Downloading package wordnet to /Users/Jialin/nltk_data...\n",
      "[nltk_data]   Package wordnet is already up-to-date!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import nltk\n",
    "from nltk.corpus import stopwords\n",
    "from nltk.stem import WordNetLemmatizer\n",
    "nltk.download('stopwords')\n",
    "nltk.download('wordnet')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 321,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.metrics import roc_curve, auc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.preprocessing.text import one_hot\n",
    "from keras.preprocessing.text import Tokenizer\n",
    "from keras.preprocessing.sequence import pad_sequences\n",
    "from keras.models import Sequential\n",
    "from keras.layers.core import Activation, Dropout, Dense, Dropout\n",
    "from keras.layers import Flatten, Conv1D, LSTM, MaxPooling1D, SpatialDropout1D, GlobalMaxPooling1D\n",
    "from keras.layers.embeddings import Embedding\n",
    "from keras.callbacks import EarlyStopping\n",
    "from keras.regularizers import l2\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.metrics import roc_curve, auc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"dataset.csv\", encoding = 'utf-8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7395"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>text</th>\n",
       "      <th>cat</th>\n",
       "      <th>topic</th>\n",
       "      <th>cluster</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>SeaWorld’s profits fell by 84% and customers a...</td>\n",
       "      <td>ele</td>\n",
       "      <td>SeaWorld</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>The company teaches dolphins and killer whales...</td>\n",
       "      <td>ele</td>\n",
       "      <td>SeaWorld</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>It says fewer people are going to its parks an...</td>\n",
       "      <td>ele</td>\n",
       "      <td>SeaWorld</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>SeaWorld has been in the news since the 2013 d...</td>\n",
       "      <td>ele</td>\n",
       "      <td>SeaWorld</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>Animal rights organizations say that orcas kep...</td>\n",
       "      <td>ele</td>\n",
       "      <td>SeaWorld</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                text  cat     topic  cluster\n",
       "0  SeaWorld’s profits fell by 84% and customers a...  ele  SeaWorld      2.0\n",
       "1  The company teaches dolphins and killer whales...  ele  SeaWorld      2.0\n",
       "2  It says fewer people are going to its parks an...  ele  SeaWorld      2.0\n",
       "3  SeaWorld has been in the news since the 2013 d...  ele  SeaWorld      2.0\n",
       "4  Animal rights organizations say that orcas kep...  ele  SeaWorld      2.0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "# convert cat to numeric levels\n",
    "# 0: ele, 1: int, 2: adv\n",
    "level = []\n",
    "for c in df.cat:\n",
    "    if c == 'ele':\n",
    "        level.append(0)\n",
    "    elif c == 'int':\n",
    "        level.append(1)\n",
    "    elif c == 'adv':\n",
    "        level.append(2)\n",
    "\n",
    "df['level'] = level"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>text</th>\n",
       "      <th>cat</th>\n",
       "      <th>topic</th>\n",
       "      <th>cluster</th>\n",
       "      <th>level</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>SeaWorld’s profits fell by 84% and customers a...</td>\n",
       "      <td>ele</td>\n",
       "      <td>SeaWorld</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>The company teaches dolphins and killer whales...</td>\n",
       "      <td>ele</td>\n",
       "      <td>SeaWorld</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>It says fewer people are going to its parks an...</td>\n",
       "      <td>ele</td>\n",
       "      <td>SeaWorld</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>SeaWorld has been in the news since the 2013 d...</td>\n",
       "      <td>ele</td>\n",
       "      <td>SeaWorld</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>Animal rights organizations say that orcas kep...</td>\n",
       "      <td>ele</td>\n",
       "      <td>SeaWorld</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                text  cat     topic  cluster  \\\n",
       "0  SeaWorld’s profits fell by 84% and customers a...  ele  SeaWorld      2.0   \n",
       "1  The company teaches dolphins and killer whales...  ele  SeaWorld      2.0   \n",
       "2  It says fewer people are going to its parks an...  ele  SeaWorld      2.0   \n",
       "3  SeaWorld has been in the news since the 2013 d...  ele  SeaWorld      2.0   \n",
       "4  Animal rights organizations say that orcas kep...  ele  SeaWorld      2.0   \n",
       "\n",
       "   level  \n",
       "0      0  \n",
       "1      0  \n",
       "2      0  \n",
       "3      0  \n",
       "4      0  "
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Text Cleaning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 323,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Cleaning the text\n",
    "import string\n",
    "def text_process(text):\n",
    "    '''\n",
    "    Takes in a string of text, then performs the following:\n",
    "    1. Remove all punctuation\n",
    "    2. Remove all stopwords\n",
    "    3. Return the cleaned text as a list of words\n",
    "    4. Remove words\n",
    "    '''\n",
    "    stemmer = WordNetLemmatizer()\n",
    "    nopunc = [char for char in text if char not in string.punctuation]\n",
    "    nopunc = ''.join([i for i in nopunc if not i.isdigit()])\n",
    "    nopunc =  [word.lower() for word in nopunc.split()]\n",
    "    return ' '.join([stemmer.lemmatize(word) for word in nopunc])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 326,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/Jialin/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:1: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n",
      "/Users/Jialin/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:2: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  \n",
      "/Users/Jialin/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:3: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  This is separate from the ipykernel package so we can avoid doing imports until\n"
     ]
    }
   ],
   "source": [
    "cluster_df0['text'] = cluster_df0['text'].map(lambda com : text_process(com))\n",
    "cluster_df1['text'] = cluster_df1['text'].map(lambda com : text_process(com))\n",
    "cluster_df2['text'] = cluster_df2['text'].map(lambda com : text_process(com))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 306,
   "metadata": {},
   "outputs": [],
   "source": [
    "# cluster_df0.to_csv('cluster0.csv',index=False)\n",
    "# cluster_df1.to_csv('cluster1.csv',index=False)\n",
    "# cluster_df2.to_csv('cluster2.csv',index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # topic list\n",
    "# cluster_text0 = []\n",
    "# #cluster_text1 = []\n",
    "# #cluster_text2 = []\n",
    "# for t in cluster_df0.text:\n",
    "#     myt = text_process(t)\n",
    "#     if (t not in cluster_text0):\n",
    "#         cluster_text0.append(myt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train and Test Split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 482,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(list(df['text']), list(df.level), test_size=0.2, random_state=45)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 469,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(list(cluster_df0['text']), list(cluster_df0.level), test_size=0.2, random_state=45)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 474,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(list(cluster_df1['text']), list(cluster_df1.level), test_size=0.2, random_state=45)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 478,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(list(cluster_df2['text']), list(cluster_df2.level), test_size=0.2, random_state=45)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tokenization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "#API embedding\n",
    "# tokenizer = Tokenizer(num_words=5000)\n",
    "# tokenizer.fit_on_texts(X_train)\n",
    "\n",
    "# X_train = tokenizer.texts_to_sequences(X_train)\n",
    "# X_test = tokenizer.texts_to_sequences(X_test)\n",
    "# # Adding 1 because of reserved 0 index\n",
    "# vocab_size = len(tokenizer.word_index) + 1\n",
    "\n",
    "# maxlen = 50\n",
    "\n",
    "# X_train = pad_sequences(X_train, padding='post', maxlen=maxlen)\n",
    "# X_test = pad_sequences(X_test, padding='post', maxlen=maxlen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "# word embeddings\n",
    "embeddings_dictionary = dict()\n",
    "glove_file = open('/Users/Jialin/Downloads/OneStopEnglishCorpus-master/glove/glove.6B.50d.txt', encoding=\"utf8\")\n",
    "\n",
    "for line in glove_file:\n",
    "    records = line.split()\n",
    "    word = records[0]\n",
    "    vector_dimensions = np.asarray(records[1:], dtype='float32')\n",
    "    embeddings_dictionary[word] = vector_dimensions\n",
    "glove_file.close()\n",
    "\n",
    "embedding_matrix = np.zeros((vocab_size, 50))\n",
    "for word, index in tokenizer.word_index.items():\n",
    "    embedding_vector = embeddings_dictionary.get(word)\n",
    "    if embedding_vector is not None:\n",
    "        embedding_matrix[index] = embedding_vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 483,
   "metadata": {},
   "outputs": [],
   "source": [
    "#word embedding from document\n",
    "word_tokenizer = Tokenizer(lower=False)\n",
    "word_tokenizer.fit_on_texts(X_train)\n",
    "\n",
    "X_train = tokenizer.texts_to_sequences(X_train)\n",
    "X_test = tokenizer.texts_to_sequences(X_test)\n",
    "\n",
    "vocab_size = len(word_tokenizer.word_index) + 1\n",
    "#embedded_sentences = word_tokenizer.texts_to_sequences(X_train)\n",
    "\n",
    "X_train = pad_sequences(X_train,30, padding='post')\n",
    "X_test = pad_sequences(X_test, 30, padding='post')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 484,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5916, 30)"
      ]
     },
     "execution_count": 484,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 485,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_122\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "embedding_106 (Embedding)    (None, 30, 200)           3756000   \n",
      "_________________________________________________________________\n",
      "conv1d_41 (Conv1D)           (None, 26, 64)            64064     \n",
      "_________________________________________________________________\n",
      "max_pooling1d_66 (MaxPooling (None, 6, 64)             0         \n",
      "_________________________________________________________________\n",
      "lstm_97 (LSTM)               (None, 128)               98816     \n",
      "_________________________________________________________________\n",
      "dense_153 (Dense)            (None, 1)                 129       \n",
      "=================================================================\n",
      "Total params: 3,919,009\n",
      "Trainable params: 3,919,009\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "Train on 4732 samples, validate on 1184 samples\n",
      "Epoch 1/5\n",
      "4732/4732 [==============================] - 10s 2ms/step - loss: -0.8059 - acc: 0.3468 - f1_m: 0.8253 - precision_m: 0.7149 - recall_m: 0.9939 - val_loss: -1.7593 - val_acc: 0.3590 - val_f1_m: 0.8388 - val_precision_m: 0.7245 - val_recall_m: 1.0000\n",
      "Epoch 2/5\n",
      "4732/4732 [==============================] - 4s 885us/step - loss: -2.8538 - acc: 0.3555 - f1_m: 0.8305 - precision_m: 0.7148 - recall_m: 0.9947 - val_loss: -3.2972 - val_acc: 0.3767 - val_f1_m: 0.8539 - val_precision_m: 0.7547 - val_recall_m: 0.9878\n",
      "Epoch 3/5\n",
      "4732/4732 [==============================] - 4s 905us/step - loss: -7.1881 - acc: 0.4349 - f1_m: 0.8624 - precision_m: 0.7975 - recall_m: 0.9437 - val_loss: -4.5485 - val_acc: 0.4020 - val_f1_m: 0.8406 - val_precision_m: 0.7770 - val_recall_m: 0.9188\n",
      "Epoch 4/5\n",
      "4732/4732 [==============================] - 4s 901us/step - loss: -11.1759 - acc: 0.5082 - f1_m: 0.8956 - precision_m: 0.8754 - recall_m: 0.9189 - val_loss: -5.7374 - val_acc: 0.3995 - val_f1_m: 0.8268 - val_precision_m: 0.7816 - val_recall_m: 0.8807\n",
      "Epoch 5/5\n",
      "4732/4732 [==============================] - 4s 892us/step - loss: -14.9166 - acc: 0.5435 - f1_m: 0.9188 - precision_m: 0.9139 - recall_m: 0.9262 - val_loss: -6.8513 - val_acc: 0.4012 - val_f1_m: 0.8210 - val_precision_m: 0.7742 - val_recall_m: 0.8768\n",
      "loss -5.956049101509058 accuracy 0.39080458879470825 f1 0.7991411089897156 precision 0.7601515054702759 recall 0.8535881042480469 Test Score: -5.956049101509058 Test Accuracy: 0.39080458879470825\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# LSTM + CNN\n",
    "model = Sequential()\n",
    "model.add(Embedding(vocab_size, 200, input_length=X_train.shape[1]))\n",
    "# model.add(Dropout(0.2))\n",
    "# model.add(SpatialDropout1D(0.2))\n",
    "model.add(Conv1D(64, 5, activation='relu'))\n",
    "model.add(MaxPooling1D(pool_size=4))\n",
    "# model.add(Dense(256, kernel_regularizer=l2(0.001),activation='relu', input_shape=(n_cols,)))\n",
    "# model.add(Dense(128, activation='relu'))\n",
    "# model.add(Dropout(0.2))\n",
    "model.add(LSTM(128, dropout=0.2, recurrent_dropout=0.2))\n",
    "model.add(Dense(1, activation='sigmoid'))\n",
    "model.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=['acc',f1_m,precision_m, recall_m])\n",
    "model.summary()\n",
    "# fit network\n",
    "test_model(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 426,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_96\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "embedding_80 (Embedding)     (None, 30, 200)           2174600   \n",
      "_________________________________________________________________\n",
      "dropout_25 (Dropout)         (None, 30, 200)           0         \n",
      "_________________________________________________________________\n",
      "max_pooling1d_40 (MaxPooling (None, 7, 200)            0         \n",
      "_________________________________________________________________\n",
      "lstm_71 (LSTM)               (None, 128)               168448    \n",
      "_________________________________________________________________\n",
      "dense_126 (Dense)            (None, 1)                 129       \n",
      "=================================================================\n",
      "Total params: 2,343,177\n",
      "Trainable params: 2,343,177\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "Train on 2700 samples, validate on 675 samples\n",
      "Epoch 1/6\n",
      "2700/2700 [==============================] - 6s 2ms/step - loss: -1.1388 - acc: 0.3552 - f1_m: 0.8392 - precision_m: 0.7650 - recall_m: 0.9928 - val_loss: -0.6945 - val_acc: 0.3467 - val_f1_m: 0.8165 - val_precision_m: 0.6916 - val_recall_m: 1.0000\n",
      "Epoch 2/6\n",
      "2700/2700 [==============================] - 2s 559us/step - loss: -1.7821 - acc: 0.3541 - f1_m: 0.8364 - precision_m: 0.7206 - recall_m: 1.0000 - val_loss: -0.8423 - val_acc: 0.3467 - val_f1_m: 0.8165 - val_precision_m: 0.6916 - val_recall_m: 1.0000\n",
      "Epoch 3/6\n",
      "2700/2700 [==============================] - 1s 542us/step - loss: -2.0885 - acc: 0.3541 - f1_m: 0.8353 - precision_m: 0.7190 - recall_m: 1.0000 - val_loss: -1.0288 - val_acc: 0.3467 - val_f1_m: 0.8165 - val_precision_m: 0.6916 - val_recall_m: 1.0000\n",
      "Epoch 4/6\n",
      "2700/2700 [==============================] - 1s 543us/step - loss: -3.3097 - acc: 0.3541 - f1_m: 0.8388 - precision_m: 0.7240 - recall_m: 1.0000 - val_loss: -1.6232 - val_acc: 0.3585 - val_f1_m: 0.8254 - val_precision_m: 0.7058 - val_recall_m: 0.9981\n",
      "Epoch 5/6\n",
      "2700/2700 [==============================] - 2s 566us/step - loss: -5.5515 - acc: 0.3674 - f1_m: 0.8488 - precision_m: 0.7468 - recall_m: 0.9882 - val_loss: -1.9105 - val_acc: 0.3600 - val_f1_m: 0.8226 - val_precision_m: 0.7045 - val_recall_m: 0.9923\n",
      "Epoch 6/6\n",
      "2700/2700 [==============================] - 1s 543us/step - loss: -8.5357 - acc: 0.4222 - f1_m: 0.8680 - precision_m: 0.7981 - recall_m: 0.9612 - val_loss: -2.2965 - val_acc: 0.3778 - val_f1_m: 0.8103 - val_precision_m: 0.7363 - val_recall_m: 0.9067\n"
     ]
    }
   ],
   "source": [
    "# LSTM only\n",
    "model = Sequential()\n",
    "model.add(Embedding(vocab_size, 200, input_length=X_train.shape[1]))\n",
    "model.add(Dropout(0.2))\n",
    "# model.add(SpatialDropout1D(0.2))\n",
    "# model.add(Conv1D(64, 5, activation='relu'))\n",
    "model.add(MaxPooling1D(pool_size=4))\n",
    "# model.add(Dense(256, kernel_regularizer=l2(0.001),activation='relu', input_shape=(n_cols,)))\n",
    "# model.add(Dense(128, activation='relu'))\n",
    "# model.add(Dropout(0.2))\n",
    "model.add(LSTM(128, dropout=0.2, recurrent_dropout=0.2))\n",
    "model.add(Dense(1, activation='sigmoid'))\n",
    "model.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=['acc',f1_m,precision_m, recall_m])\n",
    "model.summary()\n",
    "# fit network\n",
    "test_model(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 427,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "from sklearn import svm\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "\n",
    "def SVM(df):\n",
    "    train, test = train_test_split(df, test_size=0.20, shuffle=True)\n",
    "    X_train = train.text\n",
    "    X_test = test.text\n",
    "\n",
    "    # Create feature vectors\n",
    "    vectorizer = TfidfVectorizer(min_df = 5,\n",
    "                                 max_df = 0.8,\n",
    "                                 sublinear_tf = True,\n",
    "                                 use_idf = True)\n",
    "    train_vectors = vectorizer.fit_transform(train['text'])\n",
    "    test_vectors = vectorizer.transform(test['text'])\n",
    "\n",
    "    # Perform classification with SVM, kernel=linear\n",
    "    classifier_linear = svm.SVC(kernel='linear')\n",
    "    t0 = time.time()\n",
    "    classifier_linear.fit(train_vectors, train['level'])\n",
    "    t1 = time.time()\n",
    "    prediction_linear = classifier_linear.predict(test_vectors)\n",
    "    t2 = time.time()\n",
    "    time_linear_train = t1-t0\n",
    "    time_linear_predict = t2-t1\n",
    "    # results\n",
    "    print(\"Training time: %fs; Prediction time: %fs\" % (time_linear_train, time_linear_predict))\n",
    "    # report = classification_report(test['food_pos'], prediction_linear, output_dict=True)\n",
    "    print(classification_report(test['level'], prediction_linear))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 428,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training time: 2.247839s; Prediction time: 0.445218s\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.41      0.33      0.37       251\n",
      "           1       0.33      0.34      0.34       283\n",
      "           2       0.38      0.42      0.40       310\n",
      "\n",
      "    accuracy                           0.37       844\n",
      "   macro avg       0.37      0.37      0.37       844\n",
      "weighted avg       0.37      0.37      0.37       844\n",
      "\n",
      "Training time: 0.227201s; Prediction time: 0.041394s\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.33      0.21      0.26        71\n",
      "           1       0.15      0.19      0.17        85\n",
      "           2       0.21      0.23      0.22        96\n",
      "\n",
      "    accuracy                           0.21       252\n",
      "   macro avg       0.23      0.21      0.22       252\n",
      "weighted avg       0.23      0.21      0.21       252\n",
      "\n",
      "Training time: 0.549699s; Prediction time: 0.092322s\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.38      0.21      0.27       115\n",
      "           1       0.26      0.35      0.30       135\n",
      "           2       0.28      0.29      0.28       134\n",
      "\n",
      "    accuracy                           0.29       384\n",
      "   macro avg       0.30      0.28      0.28       384\n",
      "weighted avg       0.30      0.29      0.28       384\n",
      "\n"
     ]
    }
   ],
   "source": [
    "SVM(cluster_df0)\n",
    "SVM(cluster_df1)\n",
    "SVM(cluster_df2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_15\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "embedding_15 (Embedding)     (None, 30, 200)           3155400   \n",
      "_________________________________________________________________\n",
      "conv1d_4 (Conv1D)            (None, 23, 32)            51232     \n",
      "_________________________________________________________________\n",
      "flatten_1 (Flatten)          (None, 736)               0         \n",
      "_________________________________________________________________\n",
      "dense_11 (Dense)             (None, 1)                 737       \n",
      "=================================================================\n",
      "Total params: 3,207,369\n",
      "Trainable params: 3,207,369\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "None\n",
      "Train on 4732 samples, validate on 1184 samples\n",
      "Epoch 1/6\n",
      "4732/4732 [==============================] - 2s 511us/step - loss: -0.0020 - acc: 0.3462 - f1_m: 0.8245 - precision_m: 0.7052 - recall_m: 0.9970 - val_loss: -1.2118 - val_acc: 0.3590 - val_f1_m: 0.8388 - val_precision_m: 0.7245 - val_recall_m: 1.0000\n",
      "Epoch 2/6\n",
      "4732/4732 [==============================] - 2s 383us/step - loss: -17.7534 - acc: 0.3481 - f1_m: 0.8258 - precision_m: 0.7050 - recall_m: 1.0000 - val_loss: -48.2742 - val_acc: 0.3590 - val_f1_m: 0.8388 - val_precision_m: 0.7245 - val_recall_m: 1.0000\n",
      "Epoch 3/6\n",
      "4732/4732 [==============================] - 2s 384us/step - loss: -295.3701 - acc: 0.3481 - f1_m: 0.8255 - precision_m: 0.7050 - recall_m: 1.0000 - val_loss: -394.8157 - val_acc: 0.3590 - val_f1_m: 0.8388 - val_precision_m: 0.7245 - val_recall_m: 1.0000\n",
      "Epoch 4/6\n",
      "4732/4732 [==============================] - 2s 379us/step - loss: -1392.4790 - acc: 0.3481 - f1_m: 0.8261 - precision_m: 0.7050 - recall_m: 1.0000 - val_loss: -1414.0718 - val_acc: 0.3590 - val_f1_m: 0.8388 - val_precision_m: 0.7245 - val_recall_m: 1.0000\n",
      "Epoch 5/6\n",
      "4732/4732 [==============================] - 2s 411us/step - loss: -3916.3065 - acc: 0.3481 - f1_m: 0.8255 - precision_m: 0.7050 - recall_m: 1.0000 - val_loss: -3311.1721 - val_acc: 0.3590 - val_f1_m: 0.8388 - val_precision_m: 0.7245 - val_recall_m: 1.0000\n",
      "Epoch 6/6\n",
      "4732/4732 [==============================] - 2s 415us/step - loss: -8286.2454 - acc: 0.3481 - f1_m: 0.8260 - precision_m: 0.7050 - recall_m: 1.0000 - val_loss: -6206.3588 - val_acc: 0.3590 - val_f1_m: 0.8388 - val_precision_m: 0.7245 - val_recall_m: 1.0000\n",
      "loss -5554.228834542977 accuracy 0.3536173105239868 f1 0.8266596794128418 precision 0.7089666128158569 recall 1.0 Test Score: -5554.228834542977 Test Accuracy: 0.3536173105239868\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# CNN\n",
    "model = Sequential()\n",
    "model.add(Embedding(vocab_size, 200, input_length=30))\n",
    "model.add(Conv1D(filters=32, kernel_size=8, activation='relu'))\n",
    "# model.add(MaxPooling1D(pool_size=2))\n",
    "# model.add(Dense(256, activation='relu', input_shape=(n_cols,)))\n",
    "# model.add(Dense(128, activation='relu'))\n",
    "# model.add(Dropout(0.2))\n",
    "\n",
    "# model.add(Dense(10, activation='relu'))\n",
    "model.add(Flatten())\n",
    "model.add(Dense(1, activation='sigmoid'))\n",
    "\n",
    "model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['acc',f1_m,precision_m, recall_m])\n",
    "print(model.summary())\n",
    "# fit network\n",
    "test_model(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training time: 2.411561s; Prediction time: 0.442625s\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.41      0.39      0.40       225\n",
      "           1       0.37      0.32      0.34       313\n",
      "           2       0.39      0.46      0.42       306\n",
      "\n",
      "    accuracy                           0.39       844\n",
      "   macro avg       0.39      0.39      0.39       844\n",
      "weighted avg       0.39      0.39      0.39       844\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "from sklearn import svm\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "\n",
    "train, test = train_test_split(cluster_df0, test_size=0.20, shuffle=True)\n",
    "X_train = train.text\n",
    "X_test = test.text\n",
    "\n",
    "# Create feature vectors\n",
    "vectorizer = TfidfVectorizer(min_df = 5,\n",
    "                             max_df = 0.8,\n",
    "                             sublinear_tf = True,\n",
    "                             use_idf = True)\n",
    "train_vectors = vectorizer.fit_transform(train['text'])\n",
    "test_vectors = vectorizer.transform(test['text'])\n",
    "\n",
    "# Perform classification with SVM, kernel=linear\n",
    "classifier_linear = svm.SVC(kernel='linear')\n",
    "t0 = time.time()\n",
    "classifier_linear.fit(train_vectors, train['level'])\n",
    "t1 = time.time()\n",
    "prediction_linear = classifier_linear.predict(test_vectors)\n",
    "t2 = time.time()\n",
    "time_linear_train = t1-t0\n",
    "time_linear_predict = t2-t1\n",
    "# results\n",
    "print(\"Training time: %fs; Prediction time: %fs\" % (time_linear_train, time_linear_predict))\n",
    "# report = classification_report(test['food_pos'], prediction_linear, output_dict=True)\n",
    "print(classification_report(test['level'], prediction_linear))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 448,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras import backend as K\n",
    "\n",
    "def recall_m(y_true, y_pred):\n",
    "        true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n",
    "        possible_positives = K.sum(K.round(K.clip(y_true, 0, 1)))\n",
    "        recall = true_positives / (possible_positives + K.epsilon())\n",
    "        return recall\n",
    "\n",
    "def precision_m(y_true, y_pred):\n",
    "        true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n",
    "        predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n",
    "        precision = true_positives / (predicted_positives + K.epsilon())\n",
    "        return precision\n",
    "\n",
    "def f1_m(y_true, y_pred):\n",
    "    precision = precision_m(y_true, y_pred)\n",
    "    recall = recall_m(y_true, y_pred)\n",
    "    return 2*((precision*recall)/(precision+recall+K.epsilon()))\n",
    "\n",
    "def test_model(model):\n",
    "    history = model.fit(X_train, y_train, \n",
    "                        batch_size=64, \n",
    "                        epochs=5, \n",
    "                        verbose=1, \n",
    "                        validation_split=0.2,\n",
    "                        callbacks=[EarlyStopping(monitor='val_loss', patience=3, min_delta=0.0001)])\n",
    "    score = model.evaluate(X_test, y_test, verbose=0)\n",
    "    \n",
    "    #loss, accuracy, f1_score, precision, recall\n",
    "    print(\"loss {} accuracy {} f1 {} precision {} recall {}\".format(*score), \"Test Score:\", score[0], \"Test Accuracy:\", score[1])\n",
    "\n",
    "    plt.plot(history.history['acc'])\n",
    "    plt.plot(history.history['val_acc'])\n",
    "\n",
    "    plt.title('model accuracy')\n",
    "    plt.ylabel('accuracy')\n",
    "    plt.xlabel('epoch')\n",
    "    plt.legend(['train','test'], loc='upper left')\n",
    "    plt.show()\n",
    "\n",
    "    plt.plot(history.history['loss'])\n",
    "    plt.plot(history.history['val_loss'])\n",
    "\n",
    "    plt.title('model loss')\n",
    "    plt.ylabel('loss')\n",
    "    plt.xlabel('epoch')\n",
    "    plt.legend(['train','test'], loc='upper left')\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
